from flask import Flask, jsonify, request
from flask_cors import CORS
import os
import time
import random
import requests
import hashlib
import json
import secrets
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# 记录启动时间
start_time = time.time()

# AI服务配置
AI_API_KEY = "sk-d0378514964148fab84e16e9098f31ec"
AI_ACCOUNT = "1465561500142613"
AI_API_URL = "https://api.openai.com/v1/chat/completions"  # 使用标准的OpenAI API接口格式

# 应用配置
APP_NAME = os.getenv("APP_NAME", "AI Chat System API")
VERSION = os.getenv("VERSION", "1.0.0")
DEBUG = os.getenv("DEBUG", "True").lower() == "true"

# 创建Flask应用
app = Flask(__name__)
app.config.update(
    APP_NAME=APP_NAME,
    VERSION=VERSION,
    DEBUG=DEBUG
)

# 配置CORS
CORS(app)

# 简单的JWT token生成器
class TokenGenerator:
    def __init__(self):
        self.secret_key = "homework_ai_system_secret_key_2024"
        
    def generate_token(self, user_id, username):
        """生成标准JWT格式的token"""
        header = {
            'alg': 'HS256',
            'typ': 'JWT'
        }
        
        payload = {
            'user_id': user_id,
            'username': username,
            'iat': int(time.time()),
            'exp': int(time.time()) + (24 * 60 * 60)
        }
        
        import base64
        
        def base64url_encode(data):
            encoded = base64.b64encode(data.encode('utf-8')).decode('utf-8')
            return encoded.replace('+', '-').replace('/', '_').rstrip('=')
        
        header_b64 = base64url_encode(json.dumps(header, separators=(',', ':')))
        payload_b64 = base64url_encode(json.dumps(payload, separators=(',', ':')))
        
        signing_input = f"{header_b64}.{payload_b64}"
        signature = hashlib.sha256(
            f"{signing_input}{self.secret_key}".encode('utf-8')
        ).hexdigest()
        
        return f"{header_b64}.{payload_b64}.{signature}"

# 模拟数据库 - 存储用户信息
class MockDatabase:
    def __init__(self):
        self.users = {}
        self.current_id = 1
    
    def add_user(self, username, email, password):
        if username in self.users:
            return None, "用户名已存在"
        if any(user['email'] == email for user in self.users.values()):
            return None, "邮箱已被注册"
        
        user_id = self.current_id
        self.users[username] = {
            'id': user_id,
            'username': username,
            'email': email,
            'password': password
        }
        self.current_id += 1
        return user_id, "注册成功"
    
    def verify_user(self, username, password):
        if username not in self.users:
            return None, "用户不存在"
        
        user = self.users[username]
        if user['password'] != password:
            return None, "密码错误"
        
        return user['id'], "登录成功"

# 创建全局实例
token_generator = TokenGenerator()
database = MockDatabase()

# 本地智能回复生成器
def generate_intelligent_local_reply(message):
    """基于消息内容生成智能的本地回复"""
    
    # 问候类回复
    greeting_patterns = ["你好", "hello", "hi", "嗨", "您好", "hiya", "hey", "greeting"]
    if any(pattern in message.lower() for pattern in greeting_patterns):
        greetings = [
            "您好！我是您的AI助手，很高兴为您服务！请问有什么我可以帮助您的吗？",
            "欢迎！我是AI助手，我会尽我所能回答您的问题。您想聊什么呢？",
            "嗨！很高兴见到您！有什么有趣的问题想要讨论吗？",
            "您好！我是AI助手，我会尽力为您提供有用的信息和建议。",
            "你好呀！今天过得怎么样？有什么我可以帮助您的吗？"
        ]
        return random.choice(greetings)
    
    # 数学计算类问题
    math_patterns = ["等于", "+", "-", "*", "/", "计算", "多少", "算", "一加一", "二加二", "加", "减", "乘", "除"]
    if any(pattern in message for pattern in math_patterns):
        if "一加一" in message or "1+1" in message:
            return "一加一等于二！这是一个简单的加法运算。如果您有更复杂的数学问题，我很乐意帮您解答。"
        elif "二加二" in message or "2+2" in message:
            return "二加二等于四！这是基础数学运算。如果您有其他计算需求，请告诉我。"
        elif "十加十" in message or "10+10" in message:
            return "十加十等于二十！您是想进行其他计算吗？"
        else:
            return f"我理解您想进行数学计算。对于 '{message}' 这个计算，您可以告诉我更具体的数字，我可以帮您分析解题思路。"
    
    # 感谢类回复
    thank_patterns = ["谢谢", "感谢", "thank", "感谢您", "多谢"]
    if any(pattern in message for pattern in thank_patterns):
        thanks = [
            "不客气！很高兴能帮助到您！如果您还有其他问题，随时都可以问我。",
            "不用谢！这是我应该做的。希望我的回答对您有帮助！",
            "很高兴为您服务！如果还有其他疑问，请随时告诉我。",
            "很高兴能帮到您！您随时可以就任何话题与我交流。",
            "不客气！能够帮助您是我的荣幸。有问题随时来找我哦！"
        ]
        return random.choice(thanks)
    
    # 再见类回复
    bye_patterns = ["再见", "bye", "拜拜", "回头见", "晚安", "再见啦"]
    if any(pattern in message.lower() for pattern in bye_patterns):
        byes = [
            "再见！祝您有美好的一天！如果需要我的帮助，随时欢迎回来～",
            "再见！愿您一切顺利！有任何问题都可以随时与我讨论。",
            "拜拜！感谢您的使用，希望我的回答对您有帮助！",
            "再见啦！记得有问题就来找我，我会一直在这里为您服务！",
            "再见！祝您度过愉快的一天！期待与您的下次交流！"
        ]
        return random.choice(byes)
    
    # 询问AI身份和能力
    identity_patterns = ["你是谁", "你是", "你是AI吗", "你的名字", "你能做什么", "what are you", "who are you"]
    if any(pattern in message.lower() for pattern in identity_patterns):
        identity_responses = [
            "我是您的AI助手，专门帮助您解答问题、提供建议和进行有意义的对话。虽然目前无法访问外部服务，但我会尽力根据我的知识为您提供有用的信息！",
            "我是一个AI助手，专门设计来帮助用户解答问题、讨论各种话题，并提供有价值的建议。我会在这里为您提供尽可能好的服务！",
            "我是AI智能助手，擅长回答问题、分析情况、提供建议。虽然我现在无法连接互联网，但我拥有丰富的知识来帮助您！",
            "您好！我是AI助手，一个旨在帮助用户解决问题的智能程序。我可以回答各种问题，提供建议，进行对话，以及帮助您思考和分析！"
        ]
        return random.choice(identity_responses)
    
    # 关于问题、帮助的询问
    help_patterns = ["帮助", "help", "怎么办", "如何", "怎么", "什么", "为什么", "how", "why", "what"]
    if any(pattern in message.lower() for pattern in help_patterns):
        if "如何" in message or "how" in message:
            return f"您问的是'如何{message.replace('如何', '')}'，这是一个很好的问题！我建议您可以从以下几个方面来考虑：首先明确目标，然后制定计划，再逐步实施。如果您需要更具体的建议，请告诉我更多细节！"
        elif "为什么" in message or "why" in message:
            return f"关于'{message}'这个为什么的问题，答案通常涉及多个方面。让我来分析一下可能的原因：首先是直接原因，然后是深层原因，最后是影响和意义。您希望我重点解释哪个方面呢？"
        elif "什么" in message or "what" in message:
            return f"您问的是'{message}'这个'什么'问题。为了给您更准确的回答，我需要更多信息。比如您想了解的是概念、定义、用途，还是其他方面？请告诉我您的具体需求！"
        else:
            return f"我理解您需要关于'{message}'的帮助。这是一个很有价值的问题！让我为您提供一些见解：首先，这个问题涉及多个层面；其次，不同情况下可能有不同的解决方案。您希望我从哪个角度来帮助您分析？"
    
    # 技术相关问题
    tech_patterns = ["编程", "代码", "软件", "技术", "python", "javascript", "java", "电脑", "网络", "系统"]
    if any(pattern in message.lower() for pattern in tech_patterns):
        if "python" in message.lower():
            return "您问的是Python相关的问题！Python是一种非常流行的编程语言，以其简洁的语法和强大的功能而闻名。如果您有具体的编程问题，比如语法、库使用、或者项目开发，我很乐意为您提供帮助！"
        elif "代码" in message or "code" in message.lower():
            return "您问的是代码相关的问题！编程是解决问题的创造性过程。无论您使用的是哪种编程语言，重要的是理解问题的本质，然后设计清晰的解决方案。您遇到了什么具体的编程挑战呢？"
        else:
            return f"您问的是关于'{message}'的技术问题。技术领域确实非常丰富和有趣！为了给您更准确的帮助，请告诉我您具体想了解的是哪个方面——是概念解释、实践应用，还是问题解决？"
    
    # 生活、情感类问题
    life_patterns = ["生活", "工作", "学习", "心情", "情感", "朋友", "家庭", "人生"]
    if any(pattern in message for pattern in life_patterns):
        life_responses = [
            f"您提到了'{message}'，这是一个很贴近生活的话题。生活确实充满各种挑战和机遇，每个人的经历都是独特的。我的建议是要保持积极的心态，专注于自己能控制的事情，并从每次经历中学习成长。您能告诉我更多具体情况吗？",
            f"关于'{message}'这个话题，我认为这是一个值得深思的问题。生活中的很多事情都不是非黑即白的，关键是要找到适合自己的平衡点。建议您多与信任的朋友或家人交流，他们的不同视角可能会给您新的启发。",
            f"您的这个问题很生活化！'{message}'确实是很多人都会面对的话题。我建议您可以考虑一下自己的长期目标和价值观，这往往能帮助我们做出更好的决策。同时，不要忘记照顾好自己的身心健康。"
        ]
        return random.choice(life_responses)
    
    # 长消息回复（展示分析能力）
    if len(message) > 15:
        analysis = f"您提出了一个很有深度的问题：'{message[:50]}{'...' if len(message) > 50 else ''}'。让我为您分析一下：\n\n"
        analysis += "从这个问题可以看出，您对这个问题有深入的思考。我建议从以下几个角度来看待：\n"
        analysis += "1. **核心概念**：理解问题的本质和关键要素\n"
        analysis += "2. **实际应用**：考虑如何在实践中应用这些概念\n"
        analysis += "3. **可能挑战**：预见可能遇到的困难和解决方案\n"
        analysis += "4. **持续改进**：随着时间推移不断优化和调整\n\n"
        analysis += "如果您能提供更多具体信息，我可以给出更有针对性的建议！"
        return analysis
    
    # 默认智能回复
    default_responses = [
        f"我理解您的问题：'{message}'。这是一个很有趣的话题！虽然我的知识有限，但我会尽力为您提供有用的见解。如果您能提供更多背景信息，我可以给您更准确的回答。",
        f"您的问题是'{message[:30]}{'...' if len(message) > 30 else ''}'。让我来思考一下：这类问题通常涉及多个方面的考虑。我建议您可以从问题的根本原因开始分析，然后寻找相应的解决方案。",
        f"谢谢您提出'{message[:20]}{'...' if len(message) > 20 else ''}'这个问题！我认为这是一个很好的思考起点。为了给您更详细和准确的信息，请问您能补充一些具体的情况或背景吗？",
        f"您的问题很有意义：'{message}'。从我的角度来看，这个话题有很多值得探讨的方面。我会推荐您多角度思考问题，这样可以更全面地理解情况并找到最佳解决方案。",
        f"我注意到您提到了'{message[:25]}{'...' if len(message) > 25 else ''}'。这确实是一个值得深入讨论的话题！建议您可以考虑这个问题在不同情境下的表现，这样能帮助您获得更全面的理解。"
    ]
    
    return random.choice(default_responses)

# 简单的健康检查路由
@app.route("/", methods=["GET"])
def root():
    return jsonify({
        "message": f"Welcome to {APP_NAME}",
        "version": VERSION,
        "docs": "/docs"
    })

@app.route("/health", methods=["GET"])
def health_check():
    return jsonify({
        "status": "healthy",
        "service": APP_NAME
    })

# 用户注册接口
@app.route("/api/auth/register", methods=["POST"])
def register():
    try:
        if not request.is_json:
            return jsonify({
                "success": False,
                "message": "请求格式必须是JSON"
            }), 400
        
        data = request.get_json()
        username = data.get('username', '').strip()
        email = data.get('email', '').strip()
        password = data.get('password', '').strip()
        
        if not username or not email or not password:
            return jsonify({
                "success": False,
                "message": "用户名、邮箱和密码不能为空"
            }), 400
        
        # 注册用户
        user_id, message = database.add_user(username, email, password)
        
        if user_id:
            # 生成JWT格式的token
            token = token_generator.generate_token(user_id, username)
            
            return jsonify({
                "success": True,
                "message": message,
                "data": {
                    "id": user_id,
                    "username": username,
                    "email": email,
                    "token": token
                }
            }), 200
        else:
            return jsonify({
                "success": False,
                "message": message
            }), 400
            
    except Exception as e:
        return jsonify({
            "success": False,
            "message": f"注册过程中发生错误: {str(e)}"
        }), 500

# 用户登录接口
@app.route("/api/auth/login", methods=["POST"])
def login():
    try:
        if not request.is_json:
            return jsonify({
                "success": False,
                "message": "请求格式必须是JSON"
            }), 400
        
        data = request.get_json()
        username = data.get('username', '').strip()
        password = data.get('password', '').strip()
        
        if not username or not password:
            return jsonify({
                "success": False,
                "message": "用户名和密码不能为空"
            }), 400
        
        # 验证用户
        user_id, message = database.verify_user(username, password)
        
        if user_id:
            # 查找用户信息
            user = None
            for u in database.users.values():
                if u['id'] == user_id:
                    user = u
                    break
            
            # 生成JWT格式的token
            token = token_generator.generate_token(user_id, user['username'])
            
            return jsonify({
                "success": True,
                "message": message,
                "data": {
                    "id": user_id,
                    "username": user['username'],
                    "email": user['email'],
                    "token": token
                }
            }), 200
        else:
            return jsonify({
                "success": False,
                "message": message
            }), 401
            
    except Exception as e:
        return jsonify({
            "success": False,
            "message": f"登录过程中发生错误: {str(e)}"
        }), 500

# 获取可用的AI模型列表
@app.route("/api/ai/models", methods=["GET"])
def get_ai_models():
    try:
        models = [
            {
                "id": "qwen-turbo",
                "name": "通义千问 Turbo",
                "description": "高性能模型，响应迅速，适合日常对话",
                "type": "free"
            },
            {
                "id": "qwen-plus",
                "name": "通义千问 Plus",
                "description": "高级模型，能力更强，适合复杂任务",
                "type": "free"
            },
            {
                "id": "qwen-max",
                "name": "通义千问 Max",
                "description": "专业模型，性能最强，适合专业领域",
                "type": "free"
            }
        ]
        return jsonify(models)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# AI聊天接口 - 使用真实的AI服务
@app.route("/api/ai/chat", methods=["POST"])
def ai_chat():
    try:
        # 获取并验证请求数据
        if not request.is_json:
            print("AI聊天请求格式错误：不是JSON格式")
            return jsonify({
                "error": "请求格式必须是JSON",
                "success": False,
                "message": "请求格式错误，请检查您的输入"
            }), 400
        
        data = request.get_json()
        message = data.get("message", "").strip()
        model_id = data.get("modelId", "qwen-turbo")
        
        if not message:
            return jsonify({
                "error": "消息内容不能为空",
                "success": False,
                "message": "请输入您的问题"
            }), 400
        
        print(f"收到AI聊天请求，模型: {model_id}，消息: {message}")
        
        # 尝试调用真实的AI服务
        ai_response = None
        try:
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {AI_API_KEY}",
                "X-Account-ID": AI_ACCOUNT
            }
            
            # 为不同模型提供适当的映射
            model_mapping = {
                "qwen-turbo": "gpt-3.5-turbo",
                "qwen-plus": "gpt-3.5-turbo",
                "qwen-max": "gpt-4"
            }
            
            # 使用映射后的模型名称，如果没有映射则使用原模型名
            target_model = model_mapping.get(model_id, model_id)
            print(f"映射模型名称: {model_id} -> {target_model}")
            
            payload = {
                "model": target_model,
                "messages": [
                    {"role": "system", "content": "你是一个友好的AI助手，帮助用户解答问题。"},
                    {"role": "user", "content": message}
                ],
                "temperature": 0.7,
                "max_tokens": 500
            }
            
            response = requests.post(AI_API_URL, headers=headers, json=payload, timeout=30)
            print(f"AI API响应状态码: {response.status_code}")
            
            if response.status_code == 200:
                try:
                    result = response.json()
                    if "choices" in result and result["choices"]:
                        ai_response = result["choices"][0]["message"]["content"].strip()
                        print(f"AI服务返回成功响应: {ai_response[:100]}...")
                    else:
                        print("AI API返回数据格式异常，缺少choices字段")
                except ValueError:
                    print("AI API返回非JSON格式响应")
            else:
                print(f"AI API返回错误状态码: {response.status_code}，响应内容: {response.text[:200]}...")
            
        except requests.exceptions.Timeout:
            print("AI API请求超时")
            # 记录详细的超时信息
            print(f"请求URL: {AI_API_URL}")
            print(f"请求模型: {target_model}")
        except requests.exceptions.ConnectionError as conn_error:
            print(f"AI API连接错误: {str(conn_error)}")
            print(f"无法连接到API端点: {AI_API_URL}")
        except requests.exceptions.RequestException as req_error:
            print(f"AI API请求异常: {str(req_error)}")
        except Exception as api_error:
            print(f"AI API调用失败: {str(api_error)}")
            # 捕获并显示可能的JSON解析错误
            if 'response' in locals():
                try:
                    error_response = response.json()
                    print(f"API错误详情: {error_response}")
                except:
                    print(f"原始响应内容: {response.text[:200]}...")
        
        # 如果AI API调用失败或返回格式异常，使用本地智能回复
        if not ai_response:
            print("使用本地智能回复机制")
            ai_response = generate_intelligent_local_reply(message)
        
        # 返回标准格式的响应
        return jsonify({
            "response": ai_response,
            "modelId": model_id,
            "success": True,
            "message": ai_response,
            "content": ai_response
        })
        
    except Exception as e:
        error_message = str(e)
        print(f"AI聊天接口发生未预期错误: {error_message}")
        return jsonify({
            "error": error_message,
            "success": False,
            "message": "AI服务暂时不可用，请稍后再试"
        }), 500

# 获取用户的聊天室列表
@app.route("/api/chat/rooms", methods=["GET"])
def get_chat_rooms():
    try:
        rooms = [
            {
                "id": 1,
                "name": "AI助手",
                "roomType": "ai",
                "createdAt": "2024-01-01T00:00:00Z"
            },
            {
                "id": 2,
                "name": "项目讨论组",
                "roomType": "normal",
                "createdAt": "2024-01-01T00:00:00Z"
            },
            {
                "id": 3,
                "name": "技术分享群",
                "roomType": "normal",
                "createdAt": "2024-01-01T00:00:00Z"
            }
        ]
        return jsonify(rooms)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 创建新聊天室
@app.route("/api/chat/rooms", methods=["POST"])
def create_chat_room():
    try:
        data = request.get_json()
        room = {
            "id": int(time.time()),
            "name": data.get("name", "新聊天室"),
            "roomType": data.get("roomType", "normal"),
            "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ")
        }
        return jsonify(room), 201
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 获取聊天室消息
@app.route("/api/chat/rooms/<int:room_id>/messages", methods=["GET"])
def get_room_messages(room_id):
    try:
        messages = [
            {
                "id": 1,
                "content": "欢迎使用AI聊天助手！",
                "senderType": "ai",
                "senderName": "AI",
                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                "chatRoomId": room_id
            },
            {
                "id": 2,
                "content": "您好！我是您的AI助手，有什么可以帮助您的吗？",
                "senderType": "ai",
                "senderName": "AI",
                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
                "chatRoomId": room_id
            }
        ]
        return jsonify(messages)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 发送消息到聊天室
@app.route("/api/chat/rooms/<int:room_id>/messages", methods=["POST"])
def send_message_to_room(room_id):
    try:
        data = request.get_json()
        content = data.get("content", "")
        
        # 用户消息
        user_message = {
            "id": int(time.time()),
            "content": content,
            "senderType": "user",
            "senderName": "用户",
            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
            "chatRoomId": room_id
        }
        
        return jsonify(user_message)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 离开聊天室
@app.route("/api/chat/rooms/<int:room_id>/leave", methods=["DELETE"])
def leave_chat_room(room_id):
    try:
        return jsonify({"success": True, "message": "成功离开聊天室"})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 删除聊天室
@app.route("/api/chat/rooms/<int:room_id>", methods=["DELETE"])
def delete_chat_room(room_id):
    try:
        return jsonify({"success": True, "message": "聊天室删除成功"})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

# 健康检查端点
@app.route("/api/health", methods=["GET"])
def health_check():
    """健康检查端点，用于监控服务状态"""
    try:
        return jsonify({
            "status": "healthy",
            "service": APP_NAME,
            "version": VERSION,
            "timestamp": time.time(),
            "uptime": time.time() - start_time if 'start_time' in globals() else 0
        })
    except Exception as e:
        return jsonify({
            "status": "unhealthy",
            "error": str(e),
            "service": APP_NAME,
            "timestamp": time.time()
        }), 500

# API文档路由
@app.route("/docs", methods=["GET"])
def docs():
    return jsonify({
        "endpoints": [
            {
                "path": "/",
                "method": "GET",
                "description": "Welcome endpoint"
            },
            {
                "path": "/health",
                "method": "GET",
                "description": "Health check endpoint"
            },
            {
                "path": "/api/auth/register",
                "method": "POST",
                "description": "User registration endpoint",
                "payload_example": {"username": "testuser", "email": "test@example.com", "password": "password123"}
            },
            {
                "path": "/api/auth/login",
                "method": "POST",
                "description": "User login endpoint",
                "payload_example": {"username": "testuser", "password": "password123"}
            },
            {
                "path": "/api/ai/models",
                "method": "GET",
                "description": "Get available AI models"
            },
            {
                "path": "/api/ai/chat",
                "method": "POST",
                "description": "AI chat endpoint",
                "payload_example": {"message": "Your question here", "modelId": "qwen-turbo"}
            },
            {
                "path": "/api/chat/rooms",
                "method": "GET",
                "description": "Get user chat rooms"
            },
            {
                "path": "/api/chat/rooms",
                "method": "POST",
                "description": "Create new chat room",
                "payload_example": {"name": "New Room", "roomType": "normal"}
            },
            {
                "path": "/api/chat/rooms/<room_id>/messages",
                "method": "GET",
                "description": "Get chat room messages"
            },
            {
                "path": "/api/chat/rooms/<room_id>/messages",
                "method": "POST",
                "description": "Send message to chat room",
                "payload_example": {"content": "Hello"}
            },
            {
                "path": "/api/chat/rooms/<room_id>/leave",
                "method": "DELETE",
                "description": "Leave chat room"
            },
            {
                "path": "/api/chat/rooms/<room_id>",
                "method": "DELETE",
                "description": "Delete chat room"
            }
        ]
    })

if __name__ == "__main__":
    # 获取端口号，优先从环境变量获取，默认为8000
    port = int(os.getenv("PORT", 8000))
    host = os.getenv("HOST", "0.0.0.0")
    debug_mode = os.getenv("DEBUG", "False").lower() == "true"
    
    print(f"🚀 {APP_NAME} v{VERSION} 启动中...")
    print(f"📍 服务地址: http://{host}:{port}")
    print(f"🔧 调试模式: {'开启' if debug_mode else '关闭'}")
    
    app.run(
        host=host,
        port=port,
        debug=debug_mode
    )